package com.my.lucky.util;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Arrays;
import java.util.stream.Collectors;
import java.util.*;
import java.util.stream.Collectors;

public class DataUtil {
    // 1亿的BigDecimal常量（推荐静态初始化，避免重复创建）
    private static final BigDecimal ONE_YI = new BigDecimal("100000000");

    /**
     * BigDecimal 转为“亿”为单位的 BigDecimal
     * @param original 原BigDecimal数值（可为null）
//     * @param scale 保留小数位数（如2表示保留2位小数）
//     * @param roundingMode 舍入模式（如四舍五入）
     * @return 亿为单位的BigDecimal，若原数值为null则返回0
     */
    public static BigDecimal convertToYi(BigDecimal original) {
        // 1. 处理null：原数值为null时返回0
        if (original == null) {
            return BigDecimal.ZERO;
        }
        // 2. 除以1亿，指定精度和舍入模式
        return original.divide(ONE_YI, 2,  RoundingMode.HALF_UP);
    }

    /**
     * 保留指定位数的小数（四舍五入）
     * @param num 要格式化的数字
     * @return 格式化后的字符串
     */
    public static String formatDecimal(double num) {
        // 使用BigDecimal避免精度问题
        BigDecimal bd = new BigDecimal(Double.toString(num))
                .setScale(2, RoundingMode.HALF_UP);
        return bd.toString();
    }


    /**
     * 处理概念字符串，统计出现次数并按要求格式化输出
     * @param input 输入的概念字符串（用逗号分隔）
     * @return 格式化后的字符串（按出现次数倒序，每2个换一行）
     */
    public static String processConcepts(String input) {
        // 1. 分割字符串并预处理（去空格、过滤空字符串）
        if (input==null || input.trim().isEmpty()){
            return "";
        }
        String[] concepts = input.split(",");
        List<String> conceptList = Arrays.stream(concepts)
                .map(String::trim)  // 去除前后空格
                .filter(s -> !s.isEmpty())  // 过滤空字符串
                .collect(Collectors.toList());

        // 2. 统计每个概念的出现次数
        Map<String, Integer> countMap = new HashMap<>();
        for (String concept : conceptList) {
            countMap.put(concept, countMap.getOrDefault(concept, 0) + 1);
        }

        // 3. 按出现次数倒序排序（次数相同则按名称正序）
        List<Map.Entry<String, Integer>> sortedEntries = new ArrayList<>(countMap.entrySet());
        sortedEntries.sort((entry1, entry2) -> {
            // 先按次数倒序
            int countCompare = Integer.compare(entry2.getValue(), entry1.getValue());
            if (countCompare != 0) {
                return countCompare;
            }
            // 次数相同则按名称正序
            return entry1.getKey().compareTo(entry2.getKey());
        });

        // 4. 格式化输出（每2个换一行）
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < sortedEntries.size(); i++) {
            Map.Entry<String, Integer> entry = sortedEntries.get(i);
            // 拼接 "概念(次数)"
            result.append(entry.getKey()).append("[").append(entry.getValue()).append("]");

            // 每2个元素后换行（最后一个元素不额外加逗号）
            if (i % 2 == 1 && i != sortedEntries.size() - 1) {
//                result.append("\n");  // 每2个换一行
                result.append(",");  // 每2个换一行
            } else if (i != sortedEntries.size() - 1) {
                result.append(",");  // 元素间用逗号分隔
            }
        }
        return result.toString();
    }

    /**
     * 处理第一个字符串：去掉[]内容，按逗号分割
     */
    public static Set<String> processFirstString(String str) {
        Set<String> resultSet = new HashSet<>();

        // 使用正则表达式去除所有[数字]形式的内容
        String processed = str.replaceAll("\\[\\d+\\]", "");

        // 按逗号分割字符串
        String[] parts = processed.split(",");

        // 添加到集合中（自动去重）
        for (String part : parts) {
            // 去除可能的空格
            String trimmed = part.trim();
            if (!trimmed.isEmpty()) {
                resultSet.add(trimmed);
            }
        }

        return resultSet;
    }

    /**
     * 处理第二个字符串：按分号分割
     */
    public static Set<String> processSecondString(String str) {
        Set<String> resultSet = new HashSet<>();

        // 按分号分割字符串
        String[] parts = str.split(";");

        // 添加到集合中（自动去重）
        for (String part : parts) {
            // 去除可能的空格
            String trimmed = part.trim();
            if (!trimmed.isEmpty()) {
                resultSet.add(trimmed);
            }
        }

        return resultSet;
    }

    /**
     * 检查两个集合是否有交集
     */
    public static boolean checkIntersection(Set<String> set1, Set<String> set2) {
        // 遍历其中一个集合，检查另一个集合是否包含该元素
        for (String element : set1) {
            if (set2.contains(element)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 找出两个集合的所有交集元素
     */
    public static Set<String> findIntersectionElements(Set<String> set1, Set<String> set2) {
        Set<String> intersection = new HashSet<>();
        for (String element : set1) {
            if (set2.contains(element)) {
                intersection.add(element);
            }
        }
        return intersection;
    }

    // 测试
    public static void main(String[] args) {
        // 示例1：原数值=123456789（1.23456789亿），保留2位小数（四舍五入）
        BigDecimal num1 = new BigDecimal("123456789");
        BigDecimal yi1 = convertToYi(num1);
        System.out.println(yi1); // 输出：1.23

        // 示例2：原数值=9876543210（98.7654321亿），保留4位小数
        BigDecimal num2 = new BigDecimal("9876543210");
        BigDecimal yi2 = convertToYi(num2);
        System.out.println(yi2); // 输出：98.7654

        // 示例3：原数值=null，返回0
//        BigDecimal yi3 = convertToYi(null, 2, RoundingMode.HALF_UP);
//        System.out.println(yi3); // 输出：0.00

        String input = "贵金属,人形机器人,消费电子,液冷服务器,黄金概念,消费电子概念,东数西算(算力),汽车整车,可控核聚变,贵金属,贵金属,贵金属,PCB概念";
        String output = processConcepts(input);
        System.out.println(output);
    }

}
